Premier pas dans l'informatique quantique

Difficultés : Débutant
Temps d'utilisation QPU : 11s

Bienvenue, hackers ! Nous sommes ravis de t'accueillir pour cet atelier. L'objectif principal de cette session pratique d'introduction est de te préparer pour ton voyage quantique en 1) te guidant pour installer qiskit 2) comment créer un compte IBM Cloud et préparer api_key et crn pour utiliser un vrai ordinateur quantique et 3) créer ton premier circuit quantique, 4) résoudre un quiz sur les états quantiques et 5) exécuter tes circuits sur un vrai ordinateur quantique et afficher le résultat.

1. Commençons par le commencement : Qiskit

Qu'est-ce que Qiskit

Le Qiskit SDK est une pile logicielle haute performance conçue pour aider les développeurs et les chercheurs à exploiter pleinement la puissance des ordinateurs quantiques à l'échelle utilitaire et au-delà. En son cœur se trouve le Qiskit SDK, un kit de développement logiciel open source pour travailler avec des ordinateurs quantiques au niveau des circuits quantiques étendus. Opérateurs et primitives. Le Qiskit SDK permet à n'importe qui d'obtenir des performances optimales sur de vrais ordinateurs quantiques en utilisant l'environnement informatique de son choix.

Au-delà du SDK, Qiskit comprend également une suite d'outils et de services haute performance comme le Qiskit Runtime Service, qui permet des calculs optimisés sur les ordinateurs quantiques IBM via le cloud en utilisant des primitives qui gèrent l'atténuation des erreurs. Le Qiskit Transpiler service, qui fournit des méthodes heuristiques et alimentées par l'IA à la pointe de la technologie pour améliorer les performances des tâches courantes d'optimisation des circuits quantiques.

Qiskit functions, un catalogue de services IBM et tiers qui facilite l'optimisation des charges de travail et l'exploitation de Qiskit pour des cas d'utilisation industriels. Que tu sois développeur de logiciels quantiques, expérimentateur quantique, scientifique informatique, ou que tu cherches simplement à démarrer, le framework modulaire et flexible de Qiskit te permet de travailler au niveau d'abstraction qui correspond le mieux à tes besoins.

Qiskit est conçu pour l'extensibilité et la personnalisation, afin que tu puisses extraire des performances de pointe et aborder de nouveaux types de problèmes. Une base de code haute performance signifie que le Qiskit SDK fonctionne plus vite, utilise moins de mémoire et produit de meilleurs résultats que jamais. Et Qiskit t'introduit également à une vaste communauté d'utilisateurs et de développeurs qui sont impatients de t'accueillir et de t'aider à répondre à tes questions. Lancé pour la première fois en 2019, le programme Qiskit advocate est une initiative mondiale centrée sur la communauté qui recrute des professionnels et des passionnés de l'informatique quantique du monde entier. Au fil des années, les advocates sont devenus des leaders reconnus dans la communauté quantique. Tu veux être le prochain leader quantique ? N'hésite pas à postuler - ici

Installer Qiskit

Tout d'abord, vérifie que la version de Python que tu utilises dans ton environnement est python>=3.10, pour t'assurer qu'elle est compatible avec la dernière version de Qiskit que nous utiliserons

from platform import python_version

print(python_version())

Si ce n'est pas le cas, tu peux le mettre à niveau en utilisant ton outil préféré. Si tu ne sais pas comment faire, voici quelques options recommandées :

MacOS: Homebrew
Linux: sudo apt-get update

Un guide détaillé sur la façon de mettre à niveau Python selon ton OS est disponible ici : How to update Python

Pour plus d'informations, consulte le wiki du QGSS(Qiskit Global Summer School) 2025 : https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Tu peux vérifier ton installation en exécutant la cellule ci-dessous. Si tu as installé correctement, elle retournera la version de qiskit.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Dépannage

Si la cellule précédente a renvoyé une erreur, tu peux choisir d'installer Qiskit dans un environnement virtuel (deux méthodes suggérées suivent). Si tu n'as pas d'erreurs, tu peux ignorer cette cellule et passer à la suivante.

Nous proposons ici deux méthodes différentes pour configurer un environnement virtuel afin d'installer Qiskit.

En utilisant venv, comme expliqué dans le guide d'installation de Qiskit.
En utilisant conda, comme expliqué dans cette vidéo de Coding with Qiskit.

2. Configure ton compte IBM Cloud

Pour utiliser un vrai ordinateur quantique, tu as besoin d'une api key - le principal billet d'entrée vers le cloud et d'un crn - le jeton qui te donnera accès à tes ressources en configurant ton compte.

Configure ton compte comme suit :

Va sur la Plateforme IBM Quantum®.
Va dans le coin supérieur droit (comme indiqué sur l'image ci-dessus), crée ton token API et copie-le dans un endroit sécurisé.
Dans la cellule suivante, remplace deleteThisAndPasteYourAPIKeyHere par ta clé API.
Va dans le coin inférieur gauche (comme indiqué sur l'image ci-dessus) et crée ton instance. Assure-toi de choisir le plan ouvert.
Une fois l'instance créée, copie le code CRN associé. Tu devras peut-être actualiser pour voir l'instance.
Dans la cellule ci-dessous, remplace deleteThisAndPasteYourCRNHere par ton code CRN.

Consulte ce guide pour plus de détails sur la configuration de ton compte IBM Cloud®.

⚠️ Remarque : Traite ta clé API comme tu le ferais avec un mot de passe sécurisé. Consulte le guide Cloud setup pour plus d'informations sur l'utilisation de ta clé API dans des environnements sécurisés et non fiables.

De plus, si tu es membre de l'université du réseau partenaire IBM, utilise l'adresse e-mail de ton institution pour ton IBM ID afin de bénéficier de l'avantage partenaire.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Ton premier Circuit Quantique

Circuits quantiques

L'unité fondamentale de Qiskit est le circuit quantique, qui est une série d'instructions qu'un ordinateur quantique peut utiliser pour travailler avec des bits quantiques d'information, également appelés qubits. Ces qubits ont des propriétés spéciales qui permettent aux ordinateurs quantiques d'aborder les problèmes différemment de ton ordinateur portable ou de ton iPhone. Qiskit est une technologie qui évolue rapidement -- bien que tu puisses encore concevoir manuellement tes circuits quantiques et décider comment tu veux les exécuter (et il y a de nombreuses bonnes raisons de le faire), IBM Quantum te fournit également des outils qui simplifient le processus. Pour des raisons d'apprentissage, nous allons concevoir un circuit très simple et l'exécuter sur un simulateur.

Nous survolons cet aperçu rapidement car, honnêtement, nous pourrions passer des heures à expliquer les bases de l'information quantique et du calcul. En fait, IBM Quantum l'a déjà fait, en produisant un cours écrit et une série de conférences vidéo consacrées au sujet. Si tu as besoin d'une mise à niveau, consulte-les !

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Opérations de base sur les Qubits et mesures

Décrire les états à un seul qubit

Commençons par examiner un seul qubit. La principale différence entre un bit classique, qui peut prendre uniquement les valeurs 0 et 1, est qu'un bit quantique, ou qubit, peut être dans les états $\vert0\rangle$ , $\vert1\rangle$ , ainsi que dans une combinaison linéaire de ces deux états. Cette caractéristique est connue sous le nom de superposition, et nous permet d'écrire l'état le plus général d'un qubit comme :

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Si nous mesurions l'état de ce qubit, nous trouverions le résultat $1$ avec la probabilité $p$ , et le résultat $0$ avec la probabilité $1-p$ . Comme tu peux le voir, la probabilité totale est $1$ , ce qui signifie que nous mesurerons effectivement soit $0$ soit $1$ , et qu'aucun autre résultat n'existe.

En plus de $p$ , tu as peut-être remarqué un autre paramètre ci-dessus. La variable $\phi$ indique la phase quantique relative entre les deux états $\vert0\rangle$ et $\vert1\rangle$ . Comme nous le découvrirons plus tard, cette phase relative est très importante. Pour l'instant, il suffit de noter que la phase quantique est ce qui permet l'interférence entre les états quantiques, nous donnant la capacité d'écrire des algorithmes quantiques pour résoudre des tâches spécifiques.

Visualiser les états quantiques

Nous visualisons les états quantiques tout au long de cet exercice en utilisant ce qu'on appelle une qsphere. Voici à quoi ressemble la qsphere pour les états $\vert0\rangle$ et $\vert1\rangle$ , respectivement. Note que la partie la plus haute de la sphère représente l'état $\vert0\rangle$ , tandis que le bas représente $\vert1\rangle$ .

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Tu peux créer exactement la même QSphere en utilisant un circuit quantique. Le vecteur d'état que nous utilisons ici est à partir de l'état $|0\rangle$ . Dans Qiskit, le qubit est initialisé dans l'état $|0\rangle$ . Essaie d'exécuter le circuit ci-dessous et vois si tu peux obtenir la même QSphere.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Maintenant, visualisons l'état $|1\rangle$ . Il ne devrait pas être surprenant que l'état de superposition avec phase quantique $\phi = 0$ et probabilité $p = 1/2$ (signifiant une probabilité égale de mesurer 0 et 1) soit affiché sur la qsphere avec deux points. Remarque cependant que la taille des cercles aux deux points est plus petite que lorsque nous avions simplement $\vert0\rangle$ et $\vert1\rangle$ ci-dessus. C'est parce que la taille des cercles est proportionnelle à la probabilité de mesurer chacun, qui est maintenant réduite de moitié.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

Dans le cas des états de superposition où la phase quantique est non nulle, la qsphere nous permet de visualiser cette phase en changeant la couleur du blob correspondant. Par exemple, l'état avec $\phi = 90^\circ$ (degrés) et probabilité $p = 1/2$ est affiché dans la qsphere ci-dessous.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Manipuler les qubits

Les qubits sont manipulés en appliquant des portes quantiques. Passons en revue les différentes portes que nous allons considérer dans les exercices suivants.

Tout d'abord, décrivons comment nous pouvons modifier la valeur de $p$ pour notre état quantique général. Pour ce faire, nous utiliserons deux portes :

Porte $X$ : Cette porte bascule entre les deux états $\vert0\rangle$ et $\vert1\rangle$ . Cette opération est identique à la porte NOT classique. Par conséquent, la porte $X$ est parfois appelée porte de basculement de bit ou porte NOT. Mathématiquement, la porte $X$ change $p$ en $1-p$ , donc en particulier de 0 à 1, et vice versa.
Porte $H$ : Cette porte nous permet de passer de l'état $\vert0\rangle$ à l'état $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ . Cet état est également connu sous le nom de $\vert+\rangle$ . Mathématiquement, cela signifie passer de $p=0, \phi=0$ à $p=1/2, \phi=0$ . Comme l'état final du qubit est une superposition de $\vert0\rangle$ et $\vert1\rangle$ , la porte de Hadamard représente une véritable opération quantique.

Remarque que les deux portes ont changé la valeur de $p$ , mais pas $\phi$ . Heureusement pour nous, il est assez facile de visualiser l'action de ces portes en regardant la figure ci-dessous.

Une fois que nous avons l'état $\vert+\rangle$ , nous pouvons alors changer la phase quantique en appliquant plusieurs autres portes. Par exemple, une porte $S$ ajoute une phase de $90$ degrés à $\phi$ , tandis que la porte $Z$ ajoute une phase de $180$ degrés à $\phi$ . Pour soustraire une phase de $90$ degrés, on peut appliquer la porte $S^\dagger$ , qui se lit S-dagger et s'écrit couramment sdg. Enfin, il y a une porte $Y$ qui applique une séquence des portes $Z$ et $X$ .

Tu peux expérimenter avec les portes $X$ , $Y$ , $Z$ , $H$ , $S$ et $S^\dagger$ pour te familiariser avec les différentes opérations et la façon dont elles affectent l'état d'un qubit. Pour ce faire, tu peux visiter Circuit Composer et démarrer notre widget de circuit. Après avoir visité le circuit composer, choisis une porte à appliquer à un qubit, puis choisis le qubit (dans les premiers exemples, le seul qubit à choisir est le qubit 0). Observe comment l'état correspondant change avec chaque porte, ainsi que la description de cet état. Il te fournira également le code qui crée le circuit quantique correspondant dans Qiskit.

Si tu veux en savoir plus sur la description des états quantiques, les opérateurs de Pauli et d'autres portes à un seul qubit, consulte Quantum Information du Système Unique du cours Basics of Quantum Information par John Watrous.

Exercices pratiques : Circuits Quantiques avec des portes à un seul Qubit

Voici quatre petits exercices pour atteindre différents états sur la qsphere. Tu peux soit les résoudre avec le circuit composer et copier-coller le code qu'il fournit dans les cellules respectives pour créer les circuits quantiques, soit insérer directement une combinaison des lignes de code suivantes dans le programme pour appliquer les différentes portes :

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

Le '(0)' indique que nous appliquons cette porte au qubit 'q0', qui est le premier (et dans ce cas le seul) qubit.

Essaie d'atteindre l'état donné sur la qsphere dans chacun des exercices suivants.

i) Commençons par effectuer un basculement de bit. L'objectif est d'atteindre l'état $\vert1\rangle$ en partant de l'état $\vert0\rangle$ .

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) Ensuite, créons une superposition. L'objectif est d'atteindre l'état $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$ .

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Combinons ces deux-là. L'objectif est d'atteindre l'état $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ .

Peux-tu combiner les deux tâches ci-dessus pour trouver la solution ?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) Enfin, passons aux nombres complexes. L'objectif est d'atteindre l'état $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Quiz Quantique avec des Gates Multi-Qubits

Bravo ! Maintenant que tu as compris les gates à un seul qubit, voyons les gates opérant sur plusieurs qubits. Tu vas devoir résoudre 4 quiz sur les états quantiques en combinant des gates à un seul qubit et des gates multi-qubits. Les gates de base pour deux qubits sont les suivantes

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Si tu veux en savoir plus sur les différentes gates multi-qubits et leurs relations, consulte Quantum Information de plusieurs systèmes, dans le cours Basics of Quantum Information de John.

Note que pour deux qubits, un état général est de la forme $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ , où $a$ , $b$ , $c$ et $d$ sont des nombres complexes dont les valeurs absolues au carré donnent la probabilité de mesurer l'état correspondant ; par ex., $|a|^2$ serait la probabilité d'aboutir à l'état '0' sur les deux qubits. Cela signifie que nous pouvons désormais avoir jusqu'à quatre points sur la qsphere.

Commençons par la gate canonique à deux qubits, la gate controlled-NOT (aussi appelée CNOT ou CX). Ici, comme pour toutes les gates contrôlées à deux qubits, un qubit est désigné comme le « contrôle », tandis que l'autre est appelé la « cible ». Si le qubit de contrôle est dans l'état $|0\rangle$ , il applique la gate identité $I$ à la cible, c'est-à-dire qu'aucune opération n'est effectuée. En revanche, si le qubit de contrôle est dans l'état $|1\rangle$ , une X-gate est appliquée au qubit cible. Ainsi, lorsque les deux qubits se trouvent dans l'un des deux états classiques, $|0\rangle$ ou $|1\rangle$ , la gate CNOT est limitée aux opérations classiques.

Cette situation change radicalement lorsqu'on applique d'abord une Hadamard gate au qubit de contrôle, le plaçant dans l'état de superposition $|+\rangle$ . L'action d'une gate CNOT sur cette entrée non classique peut produire des états hautement intriqués entre les qubits de contrôle et cibles. Si le qubit cible est initialement dans l'état $|0\rangle$ , l'état résultant est noté $|\Phi^+\rangle$ et est l'un des états de Bell ainsi désignés.

i) Construis l'état de Bell $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

Pour cet état, on aurait une probabilité $\frac{1}{2}$ de mesurer « 00 » et une probabilité $\frac{1}{2}$ de mesurer « 11 ». Ainsi, les résultats des deux qubits sont parfaitement corrélés.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

Ensuite, essaie de créer l'état de qubits parfaitement anti-corrélés. Note le signe moins ici, qui indique la phase relative entre les deux états.

ii) Construis l'état de Bell $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$ .

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Le circuit quantique décrit dans la fonction ci-dessous t'est donné. Échange les états du premier et du deuxième qubit pour obtenir cette QSphere.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Écris un programme de zéro qui crée l'état GHZ (sur trois qubits), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Exécute ton circuit et observe le résultat mesuré avec un vrai ordinateur quantique

Maintenant que tu sais construire un Circuit quantique pour manipuler un vecteur d'état de qubits. Il est temps de passer à la partie la plus passionnante : l'exécuter et voir le résultat ! Ici, tu vas apprendre la façon moderne et efficace d'exécuter tes circuits avec Qiskit.

Un Qiskit pattern est un cadre général permettant de décomposer des problèmes spécifiques à un domaine et de contextualiser les capacités requises en étapes. Cela permet la composabilité transparente des nouvelles capacités développées par les chercheurs d'IBM Quantum (et d'autres) et ouvre la voie à un avenir où les tâches de calcul quantique sont réalisées par une infrastructure informatique hétérogène puissante (CPU/GPU/QPU).

Les quatre étapes d'un Qiskit pattern sont les suivantes :

Mapper le problème aux circuits quantiques et aux opérateurs
Optimiser pour le matériel cible
Exécuter sur le matériel cible
Post-traiter les résultats

Nous venons de terminer l'Étape 1 : Mapping, en construisant des circuits quantiques pour générer l'état quantique souhaité. Maintenant, parcourons les étapes restantes pour voir les résultats.

Optimiser

Ici tu vas configurer le Backend pour exécuter les circuits — tu peux sélectionner le Backend least busy parmi les groupes de qpu accessibles, ou simplement choisir un simulateur si tu n'as plus assez de temps GPU disponible. Une fois le Backend sélectionné, le pass_manager va transpiler tes circuits dans les ensembles de gates natifs du Backend choisi et les optimiser pour obtenir de meilleurs résultats. Tu peux facilement déclarer le pass_manager en utilisant generate_preset_pass_manager et en définissant le optimization_level, un nombre plus élevé indiquant davantage d'étapes d'optimisation.

La prochaine étape est passionnante — nous allons exécuter le circuit quantique avec Qiskit Runtime !

Nous le ferons en utilisant les deux Qiskit primitives :

Sampler échantillonne le registre de sortie à partir de l'exécution d'un ou plusieurs circuits quantiques. Sa sortie est un comptage par mesure shot.
Estimator calcule la valeur attendue d'un ou plusieurs observables par rapport aux états générés par le circuit quantique. Sa sortie est constituée des valeurs attendues ainsi que de leurs erreurs standard.

Ici, nous allons utiliser Sampler pour exécuter nos circuits. La cellule de code ci-dessous te montre comment définir d'abord un Backend et un pass manager pour celui-ci. Ensuite, il ajoutera une measurement à tous les circuits et créera un tableau de circuits quantiques (pub) à passer au Sampler.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Exécuter

Exécutons nos circuits. Au cas où il y aurait une longue file d'attente dans le cloud, affiche et sauvegarde le job_id pour une utilisation ultérieure et vérifie le job_status. Après avoir vu le statut du job passer à Done, récupère le résultat du job.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Post-traitement

La dernière étape consiste à interpréter la visualisation pour comprendre les états quantiques que nous avons créés. Avant de tracer plusieurs graphiques, récupérons tous les comptages de tous les circuits. Ensuite, nous ferons 4 graphiques en catégorisant les circuits.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

Les États à Qubit Unique

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

Les États à Un Qubit en Superposition

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

États à Deux Qubits

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

États à Trois Qubits

plot_distribution(counts_all[8], legend=['qc9'])

Défi supplémentaire

As-tu trouvé du bruit dans les résultats des expériences sur le Backend réel ? L'élimination du bruit des qubits est l'un des domaines de recherche actifs. Essaie les différentes options d'atténuation et de suppression d'erreurs de Qiskit Runtime pour voir comment le bruit dans les résultats d'exécution évolue ! (Note) Ces options nécessitent plus de temps QPU.

Informations supplémentaires

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Créé par : Sophy Shin

Révisé par : Nate Earnest-Noble

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals.

1. Commençons par le commencement : Qiskit​

Qu'est-ce que Qiskit​

Installer Qiskit​

Dépannage​

2. Configure ton compte IBM Cloud ​

3. Ton premier Circuit Quantique​

Circuits quantiques​

Opérations de base sur les Qubits et mesures​

Décrire les états à un seul qubit​

Visualiser les états quantiques​

Manipuler les qubits​

Exercices pratiques : Circuits Quantiques avec des portes à un seul Qubit​

i) Commençons par effectuer un basculement de bit. L'objectif est d'atteindre l'état ∣1⟩\vert1\rangle∣1⟩ en partant de l'état ∣0⟩\vert0\rangle∣0⟩.​

ii) Ensuite, créons une superposition. L'objectif est d'atteindre l'état ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩).​

iii) Combinons ces deux-là. L'objectif est d'atteindre l'état ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩).​

iv) Enfin, passons aux nombres complexes. L'objectif est d'atteindre l'état ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩)​

4. Quiz Quantique avec des Gates Multi-Qubits​

i) Construis l'état de Bell ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩).​

ii) Construis l'état de Bell ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩).​

iii) Le circuit quantique décrit dans la fonction ci-dessous t'est donné. Échange les états du premier et du deuxième qubit pour obtenir cette QSphere.​

iv) Écris un programme de zéro qui crée l'état GHZ (sur trois qubits), ∣GHZ⟩=12(∣000⟩+∣111⟩)\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)∣GHZ⟩=2​1​(∣000⟩+∣111⟩)​

5. Exécute ton circuit et observe le résultat mesuré avec un vrai ordinateur quantique​

Optimiser​

Exécuter​

Post-traitement​

Défi supplémentaire​

Informations supplémentaires​